/**
 * mongoose操作类(封装mongodb)
 */

const mongoose = require('mongoose');
const tabConf = require('./table');
//TODO 后面放到config里面
const options = {
    user: "", pass: "", host: "127.0.0.1", port: 27017, database: "cpc",
    option: {
        useNewUrlParser: true,
        useUnifiedTopology: true
    }
};


class DBUtil {
    constructor(options, tabConf) {
        this.mongoClient = {};
        this.tabConf = tabConf;
        let {user, pass, host, port, database, option} = options;
        //mongodb://user:pass@localhost:port/database
        let uri;
        if (user && pass) {
            uri = `mongodb://${user}:${pass}@${host}:${port}/${database}`;
        } else {
            uri = `mongodb://${host}:${port}/${database}`;
        }
        mongoose.createConnection(uri, option).then(this.onConnected.bind(this)).catch(this.onError.bind(this));
        process.on('SIGINT', this.onClose.bind(this));
    }

    /**
     * 获得连接实例
     * @param table_name
     * @return {*}
     */
    getConnection(table_name) {
        if (!table_name) return;
        if (!this.tabConf[table_name]) {
            console.error('No table structure');
            return false;
        }
        let client = this.mongoClient[table_name];
        if (!client) {
            //构建用户信息表结构
            var nodeSchema = new mongoose.Schema(this.tabConf[table_name]);
            //构建model
            client = this._db.model(table_name, nodeSchema, table_name);
            this.mongoClient[table_name] = client;
        }
        return client;
    }

    /**
     * 保存数据
     * @param table_name 表名
     * @param fields 表数据
     */
    save(table_name, fields) {
        return new Promise((resolve, reject) => {
            if (!fields) {
                resolve([{msg: 'Field is not allowed for null'}]);
                return false;
            }
            for (let key in fields) {
                if (!this.tabConf[table_name][key]) {
                    resolve([{msg: 'Wrong field name'}]);
                    return false;
                }
            }
            let node_model = this.getConnection(table_name);
            let mongooseEntity = new node_model(fields);
            mongooseEntity.save(function (err, res) {
                resolve([err, res])
            });
        });
    }

    /**
     * 更新数据
     * @param table_name 表名
     * @param conditions 更新需要的条件 {_id: id, user_name: name}
     * @param update_fields 要更新的字段 {age: 21, sex: 1}
     */
    updateOne(table_name, conditions, update_fields) {
        return new Promise((resolve, reject) => {
            if (!update_fields || !conditions) {
                resolve([{msg: 'Parameter error'}]);
                return;
            }
            let node_model = this.getConnection(table_name);
            node_model.updateOne(conditions, {$set: update_fields}, function (err, res) {
                resolve([err, res]);
            });
        });
    }

    /**
     * 更新数据方法(带操作符的)
     * @param table_name 数据表名
     * @param conditions 更新条件 {_id: id, user_name: name}
     * @param update_fields 更新的操作符 {$set: {id: 123}}
     */
    updateData(table_name, conditions, update_fields, callback) {
        if (!update_fields || !conditions) {
            if (callback) callback({msg: 'Parameter error'});
            return;
        }
        var node_model = this.getConnection(table_name);
        node_model.findOneAndUpdate(conditions, update_fields, {multi: true, upsert: true}, function (err, data) {
            if (callback) callback(err, data);
        });
    }

    /**
     * 删除数据
     * @param table_name 表名
     * @param conditions 删除需要的条件 {_id: id}
     * @param callback 回调方法
     */
    remove(table_name, conditions, callback) {
        var node_model = this.getConnection(table_name);
        node_model.remove(conditions, function (err, res) {
            if (err) {
                if (callback) callback(err);
            } else {
                if (callback) callback(null, res);
            }
        });
    }

    /**
     * 查询数据
     * @param table_name 表名
     * @param conditions 查询条件
     * @param fields 待返回字段
     * @param callback 回调方法
     */
    find(table_name, conditions, fields, callback) {
        var node_model = this.getConnection(table_name);
        node_model.find(conditions, fields || null, {}, function (err, res) {
            if (err) {
                callback(err);
            } else {
                callback(null, res);
            }
        });
    }

    /**
     * 查询单条数据
     * @param table_name 表名
     * @param conditions 查询条件
     * @param callback 回调方法
     */
    findOne(table_name, conditions) {
        return new Promise((resolve, reject) => {
            var node_model = this.getConnection(table_name);
            node_model.findOne(conditions, function (err, res) {
                resolve([err, res])
            });
        });
    }

    /**
     * 根据_id查询指定的数据
     * @param table_name 表名
     * @param _id 可以是字符串或 ObjectId 对象。
     * @param callback 回调方法
     */
    findById(table_name, _id, callback) {
        var node_model = this.getConnection(table_name);
        node_model.findById(_id, function (err, res) {
            if (err) {
                callback(err);
            } else {
                callback(null, res);
            }
        });
    }

    /**
     * 返回符合条件的文档数
     * @param table_name 表名
     * @param conditions 查询条件
     * @param callback 回调方法
     */
    countDocuments(table_name, conditions, callback) {
        return new Promise((resolve, reject) => {
            var node_model = this.getConnection(table_name);
            node_model.countDocuments(conditions, function (err, res) {
                resolve([err, res]);
            });
        })

    }

    /**
     * 查询符合条件的文档并返回根据键分组的结果
     * @param table_name 表名
     * @param field 待返回的键值
     * @param conditions 查询条件
     * @param callback 回调方法
     */
    distinct(table_name, field, conditions, callback) {
        var node_model = this.getConnection(table_name);
        node_model.distinct(field, conditions, function (err, res) {
            if (err) {
                callback(err);
            } else {
                callback(null, res);
            }
        });
    }

    /**
     * 连写查询
     * @param table_name 表名
     * @param conditions 查询条件 {a:1, b:2}
     * @param options 选项：{fields: "a b c", sort: {time: -1}, limit: 10}
     * @param callback 回调方法
     */
    where(table_name, conditions, options, callback) {
        var node_model = this.getConnection(table_name);
        node_model.find(conditions)
            .select(options.fields || '')
            .sort(options.sort || {})
            .limit(options.limit || {})
            .exec(function (err, res) {
                if (err) {
                    callback(err);
                } else {
                    callback(null, res);
                }
            });
    }

    /**
     * 连接成功
     * @param err
     */
    onConnected(db) {
        this._db = db;
        console.log("Mongoose连接成功");
    }

    /**
     * 连接异常
     * @param err
     */
    onError(err) {
        console.error("Mongoose连接异常", err);
    }

    /**
     * 关闭连接
     */
    onClose() {
        this._db.close(function () {
            console.info('Mongoose disconnected through app termination');
            process.exit(0);
        });
    }
}

module.exports = new DBUtil(options, tabConf);
